home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / xml4j.jar / com / ibm / xml / parser / ContentModel.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-08-30  |  9.0 KB  |  598 lines
  1. package com.ibm.xml.parser;
  2.  
  3. import com.ibm.xml.framework.ParserState;
  4. import com.ibm.xml.framework.StringPool;
  5. import com.ibm.xml.framework.XMLErrorHandler;
  6. import java.io.Serializable;
  7. import java.util.BitSet;
  8. import java.util.Enumeration;
  9. import java.util.Hashtable;
  10. import java.util.Vector;
  11. import org.w3c.dom.Element;
  12. import org.w3c.dom.EntityReference;
  13. import org.w3c.dom.Node;
  14.  
  15. public class ContentModel implements Cloneable, Serializable {
  16.    static final long serialVersionUID = 5286575228052158978L;
  17.    private static final boolean DEBUG_VALIDATION = false;
  18.    TXDocument factory;
  19.    int type = 4;
  20.    CMNode modelGroupNode;
  21.    transient CMNode rootContentModelNode;
  22.    transient Hashtable symbolHashTable;
  23.    transient Object[] symbolNextStateTable;
  24.    transient boolean[] terminalFlag;
  25.    String pseudo;
  26.  
  27.    public ContentModel(int var1) {
  28.       this.type = var1;
  29.    }
  30.  
  31.    public ContentModel(CMNode var1) {
  32.       this.type = 4;
  33.       this.modelGroupNode = var1;
  34.    }
  35.  
  36.    public synchronized Object clone() {
  37.       ContentModel var1 = this.factory == null ? new ContentModel(this.type) : this.factory.createContentModel(this.type);
  38.       var1.setFactory(this.getFactory());
  39.       if (this.modelGroupNode != null) {
  40.          var1.modelGroupNode = this.modelGroupNode.cloneNode();
  41.       }
  42.  
  43.       var1.pseudo = this.pseudo;
  44.       return var1;
  45.    }
  46.  
  47.    public synchronized boolean equals(Object var1) {
  48.       if (var1 == null) {
  49.          return false;
  50.       } else if (!(var1 instanceof ContentModel)) {
  51.          return false;
  52.       } else {
  53.          ContentModel var2 = (ContentModel)var1;
  54.          if (var2.getType() != this.getType()) {
  55.             return false;
  56.          } else if (this.getType() != 4) {
  57.             return true;
  58.          } else {
  59.             return this.modelGroupNode == null ? true : this.modelGroupNode.equals(var2.modelGroupNode);
  60.          }
  61.       }
  62.    }
  63.  
  64.    public int hashCode() {
  65.       return this.modelGroupNode.hashCode();
  66.    }
  67.  
  68.    public String toString() {
  69.       if (this.pseudo != null) {
  70.          return this.pseudo;
  71.       } else {
  72.          String var1 = "com.ibm.xml.parser.ContentModel#toString(): Internal error";
  73.          switch (this.type) {
  74.             case 1:
  75.                var1 = "EMPTY";
  76.                break;
  77.             case 2:
  78.                var1 = "ANY";
  79.             case 3:
  80.             default:
  81.                break;
  82.             case 4:
  83.                if (this.modelGroupNode instanceof CM1op && ((CM1op)this.modelGroupNode).getNode() instanceof CMLeaf) {
  84.                   CM1op var2 = (CM1op)this.modelGroupNode;
  85.                   var1 = "(" + var2.getNode() + ")" + (char)var2.getType();
  86.                } else if (this.modelGroupNode instanceof CMLeaf) {
  87.                   var1 = "(" + this.modelGroupNode + ")";
  88.                } else {
  89.                   var1 = this.modelGroupNode.toString();
  90.                }
  91.          }
  92.  
  93.          return var1;
  94.       }
  95.    }
  96.  
  97.    public TXDocument getFactory() {
  98.       return this.factory;
  99.    }
  100.  
  101.    public void setFactory(TXDocument var1) {
  102.       this.factory = var1;
  103.    }
  104.  
  105.    public CMNode getContentModelNode() {
  106.       return this.modelGroupNode;
  107.    }
  108.  
  109.    public void setContentModelNode(CMNode var1) {
  110.       this.modelGroupNode = var1;
  111.       this.rootContentModelNode = null;
  112.    }
  113.  
  114.    public String getPseudoContentModel() {
  115.       return this.pseudo;
  116.    }
  117.  
  118.    public void setPseudoContentModel(String var1) {
  119.       this.pseudo = var1;
  120.    }
  121.  
  122.    int getType() {
  123.       return this.type;
  124.    }
  125.  
  126.    void setType(int var1) {
  127.       this.type = var1;
  128.       if (var1 == 1 || var1 == 2) {
  129.          this.modelGroupNode = null;
  130.       }
  131.  
  132.    }
  133.  
  134.    void toDFA() {
  135.       if (this.modelGroupNode != null) {
  136.          if (this.rootContentModelNode == null) {
  137.             CMLeaf var1 = new CMLeaf(" *EOC* ");
  138.             this.rootContentModelNode = new CM2op(44, this.checkPlus(this.modelGroupNode), var1);
  139.             Vector var2 = new Vector();
  140.             this.countLeaf(var2, this.rootContentModelNode);
  141.             int var3 = var2.size();
  142.             this.rootContentModelNode.prepare(var3);
  143.             this.symbolHashTable = new Hashtable();
  144.             int var4 = 0;
  145.  
  146.             for(int var5 = 0; var5 < var3; ++var5) {
  147.                String var6 = ((CMLeaf)var2.elementAt(var5)).getName();
  148.                if (var6 != null && !this.symbolHashTable.containsKey(var6)) {
  149.                   this.symbolHashTable.put(var6, new Symbol(var6, var4++));
  150.                }
  151.             }
  152.  
  153.             BitSet[] var23 = new BitSet[var3];
  154.  
  155.             for(int var7 = 0; var7 < var3; ++var7) {
  156.                var23[var7] = new BitSet(var3);
  157.             }
  158.  
  159.             this.rootContentModelNode.setFollowpos(var23);
  160.             Vector var8 = new Vector();
  161.             Vector var9 = new Vector();
  162.             Hashtable var10 = new Hashtable();
  163.             BitSet var11 = this.rootContentModelNode.firstpos();
  164.             int var12 = 0;
  165.             int var13 = 0;
  166.             int var14 = var1.getPosition();
  167.             Vector var15 = new Vector();
  168.             var10.put(var11, new Integer(var12++));
  169.             var8.addElement(var11);
  170.             var9.addElement(this.makeArrayFilledMinus1(var4));
  171.             BitSet var16 = new BitSet(var3);
  172.  
  173.             while(var13 < var12) {
  174.                var11 = (BitSet)var8.elementAt(var13++);
  175.                int[] var17 = (int[])var9.elementAt((Integer)var10.get(var11));
  176.                var15.addElement(new Boolean(var11.get(var14)));
  177.                Enumeration var18 = this.symbolHashTable.elements();
  178.  
  179.                while(var18.hasMoreElements()) {
  180.                   Symbol var19 = (Symbol)var18.nextElement();
  181.                   BitSet var20 = new BitSet(var3);
  182.  
  183.                   for(int var21 = 0; var21 < var3; ++var21) {
  184.                      if (var11.get(var21)) {
  185.                         CMLeaf var22 = (CMLeaf)var2.elementAt(var21);
  186.                         if (var22.getName().equals(var19.m_sym)) {
  187.                            var20.or(var23[var21]);
  188.                         }
  189.                      }
  190.                   }
  191.  
  192.                   if (!var16.equals(var20)) {
  193.                      if (!var10.containsKey(var20)) {
  194.                         var8.addElement(var20);
  195.                         var9.addElement(this.makeArrayFilledMinus1(var4));
  196.                         var10.put(var20, new Integer(var12++));
  197.                      }
  198.  
  199.                      var17[var19.m_id] = (Integer)var10.get(var20);
  200.                   }
  201.                }
  202.             }
  203.  
  204.             this.symbolNextStateTable = new Object[var9.size()];
  205.             var9.copyInto(this.symbolNextStateTable);
  206.             this.terminalFlag = new boolean[var9.size()];
  207.  
  208.             for(int var26 = 0; var26 < var15.size(); ++var26) {
  209.                this.terminalFlag[var26] = (Boolean)var15.elementAt(var26);
  210.             }
  211.  
  212.          }
  213.       }
  214.    }
  215.  
  216.    boolean check(TXElement var1) throws LibraryException {
  217.       if (this.type == 1) {
  218.          return !((Parent)var1).hasChildNodes();
  219.       } else if (this.type == 2) {
  220.          return true;
  221.       } else if (this.type != 4) {
  222.          throw new LibraryException("com.ibm.xml.parser.ContentModel#check(" + var1 + "): Unsupported element declaration type detected. " + this.toString());
  223.       } else {
  224.          this.toDFA();
  225.          int var2 = 0;
  226.          Object var3 = var1;
  227.          Node var4 = ((Parent)var1).getFirstChild();
  228.  
  229.          while(var4 != null || ((Node)var3).getNodeType() != 1) {
  230.             if (var4 == null) {
  231.                var4 = ((Node)var3).getNextSibling();
  232.                var3 = ((Node)var3).getParentNode();
  233.             } else if (var4.getNodeType() == 5) {
  234.                var3 = var4;
  235.                var4 = var4.getFirstChild();
  236.             } else {
  237.                short var5 = var4.getNodeType();
  238.                if (var5 == 3 && !((TXText)var4).getIsIgnorableWhitespace() || var5 == 1) {
  239.                   String var6 = var5 == 3 ? "#PCDATA" : var4.getNodeName();
  240.                   int var7 = this.getSymbolID(var6);
  241.                   if (var7 < 0) {
  242.                      return false;
  243.                   }
  244.  
  245.                   var2 = ((int[])this.symbolNextStateTable[var2])[var7];
  246.                   if (var2 < 0) {
  247.                      return false;
  248.                   }
  249.                }
  250.  
  251.                var4 = var4.getNextSibling();
  252.             }
  253.          }
  254.  
  255.          return this.terminalFlag[var2];
  256.       }
  257.    }
  258.  
  259.    Node validate(TXElement var1) {
  260.       return this.validate(var1, (ParserState)null);
  261.    }
  262.  
  263.    Node validate(TXElement var1, ParserState var2) {
  264.       if (this.type == 1) {
  265.          return ((Parent)var1).hasChildNodes() ? var1 : null;
  266.       } else if (this.type == 2) {
  267.          return null;
  268.       } else {
  269.          Object var3 = null;
  270.          if (this.type == 4) {
  271.             this.toDFA();
  272.             int var4 = 0;
  273.             Object var5 = var1;
  274.             Node var6 = ((Parent)var1).getFirstChild();
  275.  
  276.             while(var6 != null) {
  277.                short var7 = var6.getNodeType();
  278.                if (var7 == 5) {
  279.                   var5 = var6;
  280.                   var6 = var6.getFirstChild();
  281.                } else if (var7 == 1 || var7 == 3 && !((TXText)var6).getIsIgnorableWhitespace()) {
  282.                   String var8 = var7 == 3 ? "#PCDATA" : var6.getNodeName();
  283.                   int var9 = this.getSymbolID(var8);
  284.                   if (var9 < 0) {
  285.                      if (var2 != null) {
  286.                         StringPool var31 = var2.getStringPool();
  287.                         int var32 = var31.addString(var8);
  288.  
  289.                         try {
  290.                            XMLErrorHandler var33 = var2.getErrorHandler();
  291.                            var33.error1(166, var32);
  292.                         } catch (Exception var28) {
  293.                         } finally {
  294.                            var31.releaseString(var32);
  295.                         }
  296.                      }
  297.  
  298.                      var3 = var6;
  299.                      break;
  300.                   }
  301.  
  302.                   var4 = ((int[])this.symbolNextStateTable[var4])[var9];
  303.                   if (var4 < 0) {
  304.                      if (var2 != null) {
  305.                         if (var7 == 3) {
  306.                            try {
  307.                               XMLErrorHandler var10 = var2.getErrorHandler();
  308.                               var10.error(159);
  309.                            } catch (Exception var27) {
  310.                            }
  311.                         } else {
  312.                            StringPool var30 = var2.getStringPool();
  313.                            int var11 = var30.addString(var8);
  314.  
  315.                            try {
  316.                               XMLErrorHandler var14 = var2.getErrorHandler();
  317.                               var14.error1(26, var11);
  318.                            } catch (Exception var25) {
  319.                            } finally {
  320.                               var30.releaseString(var11);
  321.                            }
  322.                         }
  323.                      }
  324.  
  325.                      var3 = var6;
  326.                      break;
  327.                   }
  328.  
  329.                   var6 = var6.getNextSibling();
  330.                } else {
  331.                   var6 = var6.getNextSibling();
  332.                }
  333.  
  334.                if (var6 == null && var5 != var1) {
  335.                   var6 = ((Node)var5).getNextSibling();
  336.                   var5 = ((Node)var5).getParentNode();
  337.                }
  338.             }
  339.  
  340.             if (var3 == null && !this.terminalFlag[var4]) {
  341.                var3 = var1;
  342.             }
  343.          } else {
  344.             var3 = var1;
  345.          }
  346.  
  347.          return (Node)var3;
  348.       }
  349.    }
  350.  
  351.    Hashtable prepareTable() {
  352.       Hashtable var1 = new Hashtable();
  353.       this.toDFA();
  354.       if (this.type == 4) {
  355.          Enumeration var2 = this.symbolHashTable.elements();
  356.  
  357.          while(var2.hasMoreElements()) {
  358.             Symbol var3 = (Symbol)var2.nextElement();
  359.             var1.put(var3.m_sym, new InsertableElement(var3.m_sym, false));
  360.          }
  361.       }
  362.  
  363.       var1.put("#PCDATA", new InsertableElement("#PCDATA", false));
  364.       var1.put(" *EOC* ", new InsertableElement(" *EOC* ", false));
  365.       var1.put(" *ERROR* ", new InsertableElement(" *ERROR* ", false));
  366.       return var1;
  367.    }
  368.  
  369.    static void cleanTable(Hashtable var0) {
  370.       InsertableElement var2;
  371.       for(Enumeration var1 = var0.elements(); var1.hasMoreElements(); var2.index = -1) {
  372.          var2 = (InsertableElement)var1.nextElement();
  373.          var2.status = false;
  374.       }
  375.  
  376.       if (var0.get("#PCDATA") == null) {
  377.          var0.put("#PCDATA", new InsertableElement("#PCDATA", false));
  378.       }
  379.  
  380.       if (var0.get(" *EOC* ") == null) {
  381.          var0.put(" *EOC* ", new InsertableElement(" *EOC* ", false));
  382.       }
  383.  
  384.       if (var0.get(" *ERROR* ") == null) {
  385.          var0.put(" *ERROR* ", new InsertableElement(" *ERROR* ", false));
  386.       }
  387.  
  388.    }
  389.  
  390.    static Object[] makeLinearContents(Element var0, int var1) {
  391.       Vector var2 = new Vector();
  392.       Object var3 = var0;
  393.       Node var4 = var0.getFirstChild();
  394.  
  395.       while(var4 != null || !(var3 instanceof Element)) {
  396.          if (var4 == null) {
  397.             var4 = ((Node)var3).getNextSibling();
  398.             var3 = ((Node)var3).getParentNode();
  399.          } else if (var4 instanceof EntityReference) {
  400.             var3 = var4;
  401.             var4 = var4.getFirstChild();
  402.             if (var2.size() < var1) {
  403.                --var1;
  404.             }
  405.          } else {
  406.             var2.addElement(var4);
  407.             if (var2.size() < var1 && var3 instanceof EntityReference) {
  408.                ++var1;
  409.             }
  410.  
  411.             var4 = var4.getNextSibling();
  412.          }
  413.       }
  414.  
  415.       Object[] var5 = new Object[]{var2, new Integer(var1)};
  416.       return var5;
  417.    }
  418.  
  419.    Hashtable getInsertableElements(Element var1, int var2, Hashtable var3, boolean var4) {
  420.       cleanTable(var3);
  421.       if (this.type == 1) {
  422.          ((InsertableElement)var3.get("#PCDATA")).status = false;
  423.          ((InsertableElement)var3.get(" *EOC* ")).status = true;
  424.          InsertableElement var5 = (InsertableElement)var3.get(" *ERROR* ");
  425.          if (!var1.hasChildNodes()) {
  426.             var5.status = false;
  427.          } else {
  428.             var5.status = true;
  429.             var5.index = 0;
  430.          }
  431.       } else if (this.type == 2) {
  432.          InsertableElement var6;
  433.          for(Enumeration var15 = var3.elements(); var15.hasMoreElements(); var6.status = true) {
  434.             var6 = (InsertableElement)var15.nextElement();
  435.          }
  436.  
  437.          ((InsertableElement)var3.get(" *ERROR* ")).status = false;
  438.       } else if (this.type == 4) {
  439.          Object[] var16 = makeLinearContents(var1, var2);
  440.          var2 = (Integer)var16[1];
  441.          Vector var17 = (Vector)var16[0];
  442.          if (var2 < 0) {
  443.             var2 = 0;
  444.          } else if (var17.size() < var2) {
  445.             var2 = var17.size();
  446.          }
  447.  
  448.          this.toDFA();
  449.          int var7 = 0;
  450.          boolean var8 = false;
  451.  
  452.          int var9;
  453.          for(var9 = 0; var9 < var2; ++var9) {
  454.             Node var10 = (Node)var17.elementAt(var9);
  455.             short var11 = var10.getNodeType();
  456.             if (var11 == 3 && !((TXText)var10).getIsIgnorableWhitespace() || var11 == 1) {
  457.                String var12 = var11 == 3 ? "#PCDATA" : var10.getNodeName();
  458.                int var13 = this.getSymbolID(var12);
  459.                if (var13 < 0) {
  460.                   var8 = true;
  461.                   break;
  462.                }
  463.  
  464.                var7 = ((int[])this.symbolNextStateTable[var7])[var13];
  465.                if (var7 < 0) {
  466.                   var8 = true;
  467.                   break;
  468.                }
  469.             }
  470.          }
  471.  
  472.          if (!var8) {
  473.             InsertableElement var21;
  474.             int var22;
  475.             for(Enumeration var18 = this.symbolHashTable.elements(); var18.hasMoreElements(); var21.status = var4 ? this.checkAfterTargetPosition(var17, var2, var22) : var22 >= 0) {
  476.                Symbol var20 = (Symbol)var18.nextElement();
  477.                var21 = (InsertableElement)var3.get(var20.m_sym);
  478.                if (var21 == null) {
  479.                   var3.put(var20.m_sym, var21 = new InsertableElement(var20.m_sym));
  480.                }
  481.  
  482.                var22 = ((int[])this.symbolNextStateTable[var7])[var20.m_id];
  483.             }
  484.  
  485.             ((InsertableElement)var3.get(" *EOC* ")).status = this.terminalFlag[var7];
  486.          } else {
  487.             InsertableElement var19 = (InsertableElement)var3.get(" *ERROR* ");
  488.             var19.status = true;
  489.             var19.index = var9;
  490.          }
  491.       }
  492.  
  493.       return var3;
  494.    }
  495.  
  496.    boolean checkAfterTargetPosition(Vector var1, int var2, int var3) {
  497.       if (var3 < 0) {
  498.          return false;
  499.       } else {
  500.          for(int var4 = var2; var4 < var1.size(); ++var4) {
  501.             Node var5 = (Node)var1.elementAt(var4);
  502.             short var6 = var5.getNodeType();
  503.             if (var6 == 3 && !((TXText)var5).getIsIgnorableWhitespace() || var6 == 1) {
  504.                String var7 = var6 == 3 ? "#PCDATA" : var5.getNodeName();
  505.                int var8 = this.getSymbolID(var7);
  506.                if (var8 < 0) {
  507.                   return false;
  508.                }
  509.  
  510.                var3 = ((int[])this.symbolNextStateTable[var3])[var8];
  511.                if (var3 < 0) {
  512.                   return false;
  513.                }
  514.             }
  515.          }
  516.  
  517.          return this.terminalFlag[var3];
  518.       }
  519.    }
  520.  
  521.    Vector getChildrenOrder() {
  522.       if (this.modelGroupNode == null) {
  523.          return null;
  524.       } else {
  525.          Vector var1 = new Vector();
  526.          this.appendNode(var1, this.modelGroupNode);
  527.          return var1;
  528.       }
  529.    }
  530.  
  531.    private void appendNode(Vector var1, CMNode var2) throws LibraryException {
  532.       if (var2 instanceof CM1op) {
  533.          this.appendNode(var1, ((CM1op)var2).getNode());
  534.       } else if (var2 instanceof CM2op) {
  535.          this.appendNode(var1, ((CM2op)var2).getLeft());
  536.          this.appendNode(var1, ((CM2op)var2).getRight());
  537.       } else if (var2 instanceof CMLeaf) {
  538.          var1.addElement(((CMLeaf)var2).getName());
  539.       } else {
  540.          throw new LibraryException("com.ibm.xml.parser.ContentModel#appendNode(): Invalid CMNode detected.");
  541.       }
  542.    }
  543.  
  544.    private void countLeaf(Vector var1, CMNode var2) {
  545.       if (var2 instanceof CMLeaf) {
  546.          ((CMLeaf)var2).setPosition(var1.size());
  547.          var1.addElement(var2);
  548.       } else if (var2 instanceof CM1op) {
  549.          this.countLeaf(var1, ((CM1op)var2).getNode());
  550.       } else {
  551.          if (var2 instanceof CM2op) {
  552.             this.countLeaf(var1, ((CM2op)var2).getLeft());
  553.             this.countLeaf(var1, ((CM2op)var2).getRight());
  554.          }
  555.  
  556.       }
  557.    }
  558.  
  559.    private CMNode checkPlus(CMNode var1) {
  560.       Object var2 = null;
  561.       if (var1 instanceof CM1op) {
  562.          CM1op var3 = (CM1op)var1;
  563.          if (var3.getType() == 43) {
  564.             CMNode var4 = this.checkPlus(var3.getNode());
  565.             var2 = new CM2op(44, var4, new CM1op(42, var4.cloneNode()));
  566.          } else {
  567.             var2 = new CM1op(var3.getType(), this.checkPlus(var3.getNode()));
  568.          }
  569.       } else if (var1 instanceof CM2op) {
  570.          CM2op var5 = (CM2op)var1;
  571.          var2 = new CM2op(var5.getType(), this.checkPlus(var5.getLeft()), this.checkPlus(var5.getRight()));
  572.       } else if (var1 instanceof CMLeaf) {
  573.          if (((CMLeaf)var1).getName().equals("#PCDATA")) {
  574.             var2 = new CM1op(42, var1);
  575.          } else {
  576.             var2 = var1;
  577.          }
  578.       }
  579.  
  580.       return (CMNode)var2;
  581.    }
  582.  
  583.    private int getSymbolID(String var1) {
  584.       Symbol var2 = (Symbol)this.symbolHashTable.get(var1);
  585.       return var2 == null ? -1 : var2.m_id;
  586.    }
  587.  
  588.    private int[] makeArrayFilledMinus1(int var1) {
  589.       int[] var2 = new int[var1];
  590.  
  591.       for(int var3 = 0; var3 < var1; ++var3) {
  592.          var2[var3] = -1;
  593.       }
  594.  
  595.       return var2;
  596.    }
  597. }
  598.